package com.tunan.system.dic.service.impl;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.contant.Status;
import com.exception.InvalidParameterMainError;
import com.tunan.system.dic.error.main.DeleteTypeError;
import com.tunan.system.dic.service.IBscDicCodeService;
import com.tunan.system.persistence.dao.BscDicCodeMapper;
import com.tunan.system.persistence.model.BscDicCodeItem;
import com.tunan.system.persistence.model.BscDicCodeType;
import com.tunan.utils.BscDicCodeConverter;
import com.tunan.utils.JsonUtils;

/**
 * 数据字典逻辑实现类
 */
@Service
@Transactional
public class BscDicCodeServiceImpl implements IBscDicCodeService {

	private static Logger logger = LoggerFactory.getLogger(BscDicCodeServiceImpl.class);

	@Autowired
	private BscDicCodeMapper bscDicCodeMapper;

	/**
	 * 根据ID获取数据字典选项Form对象
	 * 
	 * @param itemId
	 *            数据字典选项主键
	 * @return 数据字典选项Form对象
	 */
	@Transactional(readOnly = true)
	public BscDicCodeItem getItemByItemId(String itemId) {
		if (itemId == null || itemId.trim().length() == 0)
			throw new InvalidParameterMainError("itemId");

		BscDicCodeItem form = bscDicCodeMapper.getItemByItemId(itemId);

		if (logger.isDebugEnabled())
			logger.debug("子项主键为：{}，加载子项对象为：{}。", itemId, form != null ? JsonUtils.toJson(form) : null);

		return form;
	}

	/**
	 * 根据ID获取数据字典类型Form对象
	 * 
	 * @param typeId
	 *            数据字典类型主键
	 * @return 数据字典类型Form对象
	 */
	@Transactional(readOnly = true)
	public BscDicCodeType getTypeByTypeId(String typeId) {
		if (typeId == null || typeId.trim().length() == 0)
			throw new InvalidParameterMainError("typeId");

		BscDicCodeType form = bscDicCodeMapper.getTypeByTypeId(typeId);

		if (logger.isDebugEnabled())
			logger.debug("类型主键为：{}，字典类型对象为：{}。", typeId, form != null ? JsonUtils.toJson(form) : null);

		return form;
	}

	/**
	 * 根据数据字典类型编号获取数据字典类型Form对象
	 * 
	 * @param typeCode
	 *            数据字典类型编号
	 * @return 数据字典类型Form对象
	 */
	@Transactional(readOnly = true)
	public BscDicCodeType getTypeByTypeCode(String typeCode) {
		if (typeCode == null || typeCode.trim().length() == 0)
			throw new InvalidParameterMainError("typeCode");

		BscDicCodeType form = bscDicCodeMapper.getTypeByTypeCode(typeCode);

		if (logger.isDebugEnabled())
			logger.debug("类型编号为：{}，字典类型对象为：{}。", typeCode, form != null ? JsonUtils.toJson(form) : null);

		return form;
	}

	/**
	 * 获取所有数据字典类型
	 * 
	 * @return 所有数据字典类型
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeType> getAllTypes(Map<String, Object> params) {
		return bscDicCodeMapper.getAllTypes(params);
	}

	/**
	 * 根据数据字典类型ID获取关联的已生效的数据字典项列表
	 * 
	 * @param typeId
	 *            数据字典类型ID
	 * @return 已生效的数据字典项Form对象列表
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> getActiveItemsByTypeId(String typeId) {
		if (typeId == null || typeId.trim().length() == 0)
			throw new InvalidParameterMainError("typeId");

		// 先从缓存获取数据
		List<BscDicCodeItem> itemList = bscDicCodeMapper.getActiveItemsByTypeId(typeId);
		if (logger.isDebugEnabled()) {
			logger.debug("成功获取字典子项列表，类型主键为：{}，返回记录数为{}。", typeId, itemList != null ? itemList.size() : null);
		}

		return itemList;
	}

	/**
	 * 根据数据字典类型编号获取关联的已生效的数据字典项列表
	 * 
	 * @param typeCode
	 *            数据字典类型编号
	 * @return 已生效的数据字典项Form对象列表
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> getActiveItemsByTypeCode(String typeCode) {
		if (typeCode == null || typeCode.trim().length() == 0)
			throw new InvalidParameterMainError("typeCode");

		// 先从缓存获取数据
		List<BscDicCodeItem> itemList = bscDicCodeMapper.getActiveItemsByTypeCode(typeCode);

		if (logger.isDebugEnabled())
			logger.debug("成功获取字典子项列表，类型编号为：{}，返回记录数为{}。", typeCode, itemList != null ? itemList.size() : null);

		return itemList;
	}

	/**
	 * 根据数据字典类型ID获取关联的所有数据字典项列表
	 * 
	 * @param typeId
	 *            数据字典类型ID
	 * @return 所有数据字典项Form对象列表
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> getAllItemsByTypeId(String typeId) {
		if (typeId == null || typeId.trim().length() == 0)
			throw new InvalidParameterMainError("typeId");

		List<BscDicCodeItem> list = bscDicCodeMapper.getAllItemsByTypeId(typeId);

		if (logger.isDebugEnabled())
			logger.debug("成功获取字典子项列表，类型主键为：{}，返回记录数为{}。", typeId, list != null ? list.size() : null);

		return list;
	}

	/**
	 * 根据数据字典类型ID获取一个树
	 * 
	 * @param typeId
	 *            数据字典类型ID
	 * @return 数据字典类型树对象，包含所有子孙节点
	 */
	@Transactional(readOnly = true)
	public BscDicCodeType tgetTypeAllByTypeId(String typeId) {
		if (typeId == null || typeId.trim().length() == 0)
			throw new InvalidParameterMainError("typeId");

		BscDicCodeType typeRoot = bscDicCodeMapper.getTypeByTypeId(typeId);

		if (typeRoot != null)
			if (logger.isDebugEnabled())
				logger.debug("成功获取类型根节点对象，类型主键为：{}。", typeId);
			else if (logger.isDebugEnabled())
				logger.debug("获取类型根节点对象为空，类型主键为：{}。", typeId);

		if (typeRoot != null) {
			// 获取子项列表并构建树
			List<BscDicCodeItem> items = bscDicCodeMapper.getAllItemsByTypeId(typeId);

			if (logger.isDebugEnabled())
				logger.debug("获取类型根节点的子项列表，类型主键为：{}，返回记录数为{}。", typeId, items != null ? items.size() : null);

			BscDicCodeConverter.buildTypeTree(typeRoot, items);
		}

		return typeRoot;
	}

	/**
	 * 根据数据字典类型编号获取一个树
	 * 
	 * @param typeCode
	 *            数据字典类型编号
	 * @return 数据字典类型树对象，包含所有子孙节点
	 */
	@Transactional(readOnly = true)
	public BscDicCodeType tgetTypeAllByTypeCode(String typeCode) {
		if (typeCode == null || typeCode.trim().length() == 0)
			throw new InvalidParameterMainError("typeCode");

		BscDicCodeType typeRoot = bscDicCodeMapper.getTypeByTypeCode(typeCode);

		if (typeRoot != null)
			if (logger.isDebugEnabled())
				logger.debug("成功获取类型根节点对象，类型编号为：{}。", typeCode);
			else if (logger.isDebugEnabled())
				logger.debug("获取类型根节点对象为空，类型编号为：{}。", typeCode);

		if (typeRoot != null) {
			// 获取子项列表并构建树
			List<BscDicCodeItem> items = bscDicCodeMapper.getAllItemsByTypeId(typeRoot.getTypeId());

			if (logger.isDebugEnabled())
				logger.debug("获取类型根节点的子项列表，类型编号为：{}，返回记录数为{}。", typeCode, items != null ? items.size() : null);

			BscDicCodeConverter.buildTypeTree(typeRoot, items);
		}

		return typeRoot;
	}

	/**
	 * 根据数据字典类型ID获取一个启用节点组成的树
	 * 
	 * @param typeId
	 *            数据字典类型ID
	 * @return 数据字典类型树对象，包含所有启用的子孙节点
	 */
	@Transactional(readOnly = true)
	public BscDicCodeType tgetTypeActiveByTypeId(String typeId) {
		if (typeId == null || typeId.trim().length() == 0)
			throw new InvalidParameterMainError("typeId");

		BscDicCodeType typeRoot = bscDicCodeMapper.getTypeByTypeId(typeId);

		if (typeRoot != null)
			if (logger.isDebugEnabled())
				logger.debug("成功获取类型根节点对象，类型主键为：{}。", typeId);
			else if (logger.isDebugEnabled())
				logger.debug("获取类型根节点对象为空，类型主键为：{}。", typeId);

		if (typeRoot != null) {
			// 获取子项列表并构建树
			List<BscDicCodeItem> items = bscDicCodeMapper.getActiveItemsByTypeId(typeId);

			if (logger.isDebugEnabled())
				logger.debug("获取类型根节点的子项列表，类型主键为：{}，返回记录数为{}。", typeId, items != null ? items.size() : null);

			BscDicCodeConverter.buildActiveTypeTree(typeRoot, items);
		}

		return typeRoot;
	}

	/**
	 * 根据数据字典类型编号获取一个启用节点组成的树
	 * 
	 * @param typeCode
	 *            数据字典类型编号
	 * @return 数据字典类型树对象，包含所有启用的子孙节点
	 */
	@Transactional(readOnly = true)
	public BscDicCodeType tgetTypeActiveByTypeCode(String typeCode) {
		if (typeCode == null || typeCode.trim().length() == 0)
			throw new InvalidParameterMainError("typeCode");

		BscDicCodeType typeRoot = bscDicCodeMapper.getTypeByTypeCode(typeCode);

		if (typeRoot != null)
			if (logger.isDebugEnabled())
				logger.debug("成功获取类型根节点对象，类型编号为：{}。", typeCode);
			else if (logger.isDebugEnabled())
				logger.debug("获取类型根节点对象为空，类型编号为：{}。", typeCode);

		if (typeRoot != null) {
			// 获取子项列表并构建树
			List<BscDicCodeItem> items = bscDicCodeMapper.getActiveItemsByTypeId(typeRoot.getTypeId());

			if (logger.isDebugEnabled())
				logger.debug("获取类型根节点的子项列表，类型编号为：{}，返回记录数为{}。", typeCode, items != null ? items.size() : null);

			BscDicCodeConverter.buildActiveTypeTree(typeRoot, items);
		}

		return typeRoot;
	}

	/**
	 * 分页查询子项
	 * 
	 * @param typeId
	 *            数据字典类型ID
	 * @param itemKeyword
	 *            查询关键字
	 * @param pager
	 *            分页对象
	 * @return 查询后的分页对象
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> pfindItems(String typeCode, String itemKeyword) {
		if (typeCode == null || typeCode.trim().length() == 0)
			throw new InvalidParameterMainError("typeCode");

		List<BscDicCodeItem> list = bscDicCodeMapper.pfindItems(typeCode, itemKeyword);

		if (logger.isDebugEnabled())
			logger.debug("成功执行分页查询数据字典子项操作，类型主键为：{}，查询关键字为：{}，返回记录数{}。", typeCode, itemKeyword,
					list != null ? list.size() : null);

		return list;
	}

	/**
	 * 分页查询数据字典类型
	 * 
	 * @param typeKeyword
	 *            查询关键字，允许为NULL
	 * @param pager
	 *            分页对象
	 * @return 查询后的分页对象
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeType> pfindTypes(String typeKeyword) {

		List<BscDicCodeType> list = bscDicCodeMapper.pfindTypes(typeKeyword);

		if (logger.isDebugEnabled())
			logger.debug("成功执行分页查询数据字典类型操作，查询关键字为：{}，返回记录数{}。", typeKeyword, list != null ? list.size() : null);

		return list;
	}

	/**
	 * 获取需要导出的数据字典类型记录
	 * 
	 * @param typeIds
	 *            要导出的数据字典类型的ID数组集合，如果typeIds数据长度为0，则导出所有的数据字典类型记录
	 * @return 数据字典类型记录集合
	 */
	@Transactional(readOnly = true)
	private List<BscDicCodeType> findExportTypes(String[] typeIds) {
		List<BscDicCodeType> list = bscDicCodeMapper.findExportTypes(typeIds);

		if (logger.isDebugEnabled())
			logger.debug("成功执行获取需要导出的数据字典类型记录操作，查询关键字为：{}，返回记录数{}。", typeIds, list != null ? list.size() : null);

		return list;
	}

	/**
	 * 获取需要导出的数据字典子项记录
	 * 
	 * @param typeIds
	 *            要导出的数据字典类型的ID数组集合，如果typeIds数据长度为0，则导出所有的数据字典类型记录
	 * @return 数据字典子项记录集合
	 */
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> findExportItems(String[] typeIds) {
		List<BscDicCodeItem> list = bscDicCodeMapper.findExportItems(typeIds);

		if (logger.isDebugEnabled())
			logger.debug("成功执行获取需要导出的数据字典子项记录操作，查询关键字为：{}，返回记录数{}。", typeIds, list != null ? list.size() : null);

		return list;
	}

	/**
	 * 保存多个数据字典子项
	 * 
	 * @param forms
	 *            要保存的数据字典子项集合
	 */
	public void saveItems(List<BscDicCodeItem> forms) {
		if (forms != null && forms.size() > 0) {
			for (BscDicCodeItem form : forms) {
				saveItem(form);
			}
		}
		if (logger.isDebugEnabled())
			logger.debug("成功执行保存数据字典子项操作，保存的对象为：{}。", JsonUtils.toJson(forms));

	}

	/**
	 * 保存多个数据字典类型对象
	 * 
	 * @param forms
	 *            要保存的数据字典类型对象集合
	 */
	public void saveTypes(List<BscDicCodeType> forms) {
		if (forms != null && forms.size() > 0) {
			for (BscDicCodeType form : forms) {
				saveType(form, null);
			}
		}
		if (logger.isDebugEnabled())
			logger.debug("成功执行保存数据字典类型操作，保存的对象为：{}。", JsonUtils.toJson(forms));
	}

	/**
	 * 根据主键ID删除对应的数据字典子项及所有递归子项
	 * 
	 * @param itemId
	 *            数据字典项ID
	 * @return true ：删除成功 ， false ：删除不成功
	 */
	public boolean deleteItemCascadeByItemId(String itemId) {
		boolean flag = false;
		if (itemId != null && itemId.trim().length() > 0) {
			BscDicCodeItem item = bscDicCodeMapper.getItemByItemId(itemId);

			if (logger.isDebugEnabled()) {
				logger.debug("成功执行获取子项对象操作，获取的子项对象为：{}。", item != null ? JsonUtils.toJson(item) : null);
			}

			if (item.getItemIsLock() != null && item.getItemIsLock().trim().equals(Status.ZERO)) {// 子项本身没有锁定
				// 获取某个子项及其所有递归子项的集合
				List<BscDicCodeItem> childList = bscDicCodeMapper.getAllItemsByItemId(item.getItemId());
				if (logger.isDebugEnabled()) {
					logger.debug("成功执行获取某个子项及其所有递归子项的集合操作，子项ID为：{}。", item.getItemId());
				}
				if (childList != null && childList.size() > 0) {
					boolean childIsLock = false;// 用来判断一个子项的所有子项是否都是没有锁定的，只有该子项的所有的子项都没有锁定的时候，才能删除此子项
					for (BscDicCodeItem child : childList) {
						if (child.getItemIsLock() != null && child.getItemIsLock().equals("1")) {// 说明有子项被锁定
							childIsLock = true;
							break;
						}
					}
					if (childIsLock == false) {// 所有子项都没有锁定，执行删除操作
						bscDicCodeMapper.deleteItemCascadeByItemId(item.getItemId());
						if (logger.isDebugEnabled()) {
							logger.debug("成功执行删除子项操作，子项ID为：{}。", item.getItemId());
						}
						flag = true;
					} else {
						if (logger.isDebugEnabled()) {
							logger.debug("子项{}的下级子项中有锁定状态的，不能执行删除操作。", item.getItemName());
						}
					}
				}
			}
		}
		return flag;
	}

	/**
	 * 根据子项ID列表删除指定子项数据并返回没删除成功的数目
	 * 
	 * @param itemIds
	 *            子项ID数组
	 * @return 没删除成功的数目
	 */
	public int deleteItemsCascadeByItemIds(String... itemIds) {
		if (itemIds == null || itemIds.length == 0)
			throw new InvalidParameterMainError("itemIds");

		int count = 0;
		if (itemIds != null) {
			for (String itemId : itemIds) {
				boolean success = deleteItemCascadeByItemId(itemId);

				if (success)
					logger.debug("成功删除字典子项，子项主键为：{}", itemId);
				// if(logger.isDebugEnabled())
				// logger.debug("成功删除字典子项，子项主键为：{}", itemId);
				// else
				// logger.error("因字典子项处于锁定状态无法删除，子项主键为：{}", itemId);
				//

				// 统计没删除成功的数目
				if (!success)
					count++;
			}
		}
		return count;
	}

	/**
	 * 根据主键ID删除数据字典类型对象
	 * 
	 * @param typeId
	 *            数据字典类型主键ID
	 * @return 被删除的类型对象的类型编号列表
	 */
	public void deleteTypeCascadeByTypeId(String typeId) {
		if (typeId == null || typeId.trim().length() == 0) {
			logger.error("typeId入参为空！");
			throw new InvalidParameterMainError("typeId");
		}

		BscDicCodeType typeForm = bscDicCodeMapper.getTypeByTypeId(typeId);
		if (logger.isDebugEnabled())
			logger.debug("根据类型主键{}获取类型记录信息{}。", typeId, JsonUtils.toJson(typeForm));

		deleteTypeCascadeByTypeForm(typeForm);
	}

	/**
	 * 删除数据字典类型及所有数据字典子项
	 * 
	 * @param typeCode
	 *            数据字典类型编号
	 */
	public void deleteTypeCascadeByTypeCode(String typeCode) {
		if (typeCode == null || typeCode.trim().length() == 0)
			throw new InvalidParameterMainError("typeCode");

		BscDicCodeType type = bscDicCodeMapper.getTypeByTypeCode(typeCode);
		if (logger.isDebugEnabled()) {
			logger.debug("根据数据字典类型编号{}获取数据字典类型对象{}。", typeCode, type);
		}
		deleteTypeCascadeByTypeForm(type);
	}

	/**
	 * 关联删除字典类型对象
	 * 
	 * @param typeForm
	 *            字典类型对象
	 * @return 是否删除成功。true表示成功，false表示锁定不能删除或删除失败
	 */
	private void deleteTypeCascadeByTypeForm(BscDicCodeType typeForm) {
		if (typeForm == null) {
			logger.error("typeForm入参为空");
			throw new InvalidParameterMainError("typeForm");
		}

		if (typeForm.getTypeIsLock() != null && typeForm.getTypeIsLock().equals(Status.ONE)) {
			logger.error("无法删除已锁定字典类型，类型编号为：{}", typeForm.getTypeCode());
			throw new DeleteTypeError(typeForm.getTypeCode(), typeForm.getTypeName());
		}

		// 删除关联子项列表
		List<BscDicCodeItem> items = bscDicCodeMapper.getAllItemsByTypeId(typeForm.getTypeId());
		if (items != null && items.size() > 0) {
			for (BscDicCodeItem item : items) {
				if (item.getItemIsLock() != null && item.getItemIsLock().equals(Status.ONE)) {
					logger.error("无法删除已锁定字典子项，子项编号为：{}", item.getItemCode());
					throw new DeleteTypeError(typeForm.getTypeCode(), typeForm.getTypeName(), item.getItemCode(),
							item.getItemName());
				}

				bscDicCodeMapper.deleteItemByItemId(item.getItemId());
				if (logger.isDebugEnabled())
					logger.debug("成功删除关联子项，子项编号为：{}。", item.getItemCode());
			}
		}

		// 删除类型本身
		bscDicCodeMapper.deleteTypeByTypeId(typeForm.getTypeId());
		if (logger.isDebugEnabled())
			logger.debug("成功删除字典类型记录本身，类型主键为：{}。", typeForm.getTypeId());

	}

	/**
	 * 删除多个未锁定的字典类型
	 */
	public void deleteTypes(String[] typeIds) {
		List<BscDicCodeType> typeFormList = bscDicCodeMapper.getTypes(typeIds);
		if (logger.isDebugEnabled())
			logger.debug("获取所有字典类型记录信息{}。", JsonUtils.toJson(typeFormList));

		for (BscDicCodeType form : typeFormList) {
			deleteUnlockType(form);
		}
	}

	/**
	 * 删除未锁定的字典类型
	 * 
	 * @param form
	 */
	private void deleteUnlockType(BscDicCodeType form) {
		if (form.getTypeIsLock() != null && form.getTypeIsLock().equals(Status.ZERO)) {// 说明未锁定
			boolean flag = true;// 用来判断是否有子项被锁定，如果有子项被锁定，则值为false

			// 获取子项
			List<BscDicCodeItem> items = bscDicCodeMapper.getAllItemsByTypeId(form.getTypeId());
			if (logger.isDebugEnabled()) {
				logger.debug("根据数据字典类型编号{}获取所有字典子项记录信息{}。", form.getTypeId(), JsonUtils.toJson(items));
			}
			if (items != null && items.size() > 0) {
				for (BscDicCodeItem item : items) {
					if (item.getItemIsLock() != null && item.getItemIsLock().equals(Status.ONE)) {
						// 如果存在被锁定的子项,则设置flag的值为false,并且跳出循环
						flag = false;
						break;
					}
				}
			}

			if (flag == true) {// 说明该字典本身没有被锁定，并且他的所有子项也没有被锁定，此时可以删除该字典类型
				this.deleteTypeCascadeByTypeForm(form);
			}
		}
	}

	/**
	 * 批量添加多个数据字典项对象
	 * 
	 * @param typeId
	 *            数据字典类型编号
	 * @param itemCount
	 *            数据字典项数目
	 */
	private void addDefaultItems(String typeId, int itemCount, Date createDate) {
		if (typeId != null && typeId.trim().length() > 0 && itemCount > 0) {
			for (int i = 1; i <= itemCount; i++) {
				BscDicCodeItem child = new BscDicCodeItem();
				child.setTypeCode(typeId);
				child.setItemId(UUID.randomUUID().toString());
				child.setItemCode(i + "");
				child.setItemName("子项" + i);
				child.setItemIsActive(Status.ONE);
				child.setItemIsLock(Status.ZERO);
				child.setItemSortNo(i - 1);
				child.setItemSubCount(0);
				child.setItemCreateTime(createDate);
				child.setItemModifyTime(createDate);
				bscDicCodeMapper.insertItem(child);
			}

			if (logger.isDebugEnabled())
				logger.debug("成功为字典类型编号为：{}的类型新增{}条默认的字典子项记录。", typeId, itemCount);
		}
	}

	/**
	 * 保存数据字典子项Form对象
	 * 
	 * @param form
	 *            数据字典子项Form对象
	 */
	public void saveItem(BscDicCodeItem form) {
		if (form != null) {

			// 修改业务字典子项
			if (form != null && form.getItemId() != null && form.getItemId().trim().length() > 0) {
				form.setItemModifyTime(new Date());
				bscDicCodeMapper.updateItem(form);

				if (logger.isDebugEnabled()) {
					logger.debug("成功更新字典子项对象，form对象为：{}。", JsonUtils.toJson(form));
				}
			} else {// 新增业务字典子项
				form.setItemId(UUID.randomUUID().toString());
				Date nowDate = new Date();
				form.setItemCreateTime(nowDate);
				form.setItemModifyTime(nowDate);

				// 设置树信息
				// setTreeInfoAfterSaveItem(form);
				bscDicCodeMapper.insertItem(form);

				if (logger.isDebugEnabled()) {
					logger.debug("成功新增字典子项对象，form对象为：{}。", JsonUtils.toJson(form));
				}
			}
		}
	}

	/**
	 * 保存数据字典类型Form对象
	 * 
	 * @param form
	 *            数据字典类型Form对象
	 */
	public void saveType(BscDicCodeType form, String oldtypeCode) {
		if (form != null) {
			if (form.getTypeId() != null && form.getTypeId().trim().length() > 0) {// 修改操作

				form.setTypeIsActive(Status.convertToZeroOrOne(form.getTypeIsActive()));
				form.setTypeIsLock(Status.convertToZeroOrOne(form.getTypeIsLock()));
				form.setTypeIsTree(Status.convertToZeroOrOne(form.getTypeIsTree()));
				form.setTypeModifyTime(new Date());

				bscDicCodeMapper.updateType(form);
				// 比较数据编码是否有更改，如果更改则修改子项对应的数据编码
				if (!oldtypeCode.equals(form.getTypeCode())) {

					bscDicCodeMapper.updateItemTypeCode(form.getTypeCode(), oldtypeCode);

				}

				if (logger.isDebugEnabled())
					logger.debug("成功更新字典类型对象，form对象为：{}。", JsonUtils.toJson(form));
			} else {// 新增操作
				form.setTypeId(UUID.randomUUID().toString());

				form.setTypeIsActive(Status.convertToZeroOrOne(form.getTypeIsActive()));
				form.setTypeIsLock(Status.convertToZeroOrOne(form.getTypeIsLock()));
				form.setTypeIsTree(Status.convertToZeroOrOne(form.getTypeIsTree()));
				Date nowDate = new Date();
				form.setTypeCreateTime(nowDate);
				form.setTypeModifyTime(nowDate);

				bscDicCodeMapper.insertType(form);

				if (logger.isDebugEnabled())
					logger.debug("成功新增字典子项对象，form对象为：{}。", JsonUtils.toJson(form));

				// 额外建立一个默认的业务字典项
				// this.addDefaultItems(form.getTypeId(), 2, nowDate);
			}
		}
	}

	/**
	 * 修改数据字典类型启用状态以及关联子项启用状态
	 * 
	 * @param typeId
	 *            数据字典类型主键
	 * @param typeIsActive
	 *            指定要修改的启用状态
	 */
	public void updateTypeIsActiveField(String typeId, String typeIsActive) {
		if (typeId == null || typeId.trim().length() == 0)
			throw new InvalidParameterMainError("typeId");
		if (!Status.isOneOrZero(typeIsActive))
			throw new InvalidParameterMainError("typeIsActive");

		bscDicCodeMapper.updateTypeIsActiveField(typeId, typeIsActive);

		if (logger.isDebugEnabled())
			logger.debug("成功{}字典类型，类型主键为：{}。", Status.isOne(typeIsActive) ? "启用" : "禁用", typeId);
	}

	/**
	 * 修改数据字典子项启用状态
	 * 
	 * @param itemId
	 *            数据字典子项主键
	 * @param itemIsActive
	 *            指定要修改的启用状态
	 */
	public void updateItemIsActiveField(String itemId, String itemIsActive) {
		if (itemId == null || itemId.trim().length() == 0)
			throw new InvalidParameterMainError("itemId");
		if (!Status.isOneOrZero(itemIsActive))
			throw new InvalidParameterMainError("itemIsActive");

		bscDicCodeMapper.updateItemIsActiveField(itemId, itemIsActive);

		if (logger.isDebugEnabled())
			logger.debug("成功{}字典子项，子项主键为：{}。", Status.isOne(itemIsActive) ? "启用" : "禁用", itemId);
	}

	/**
	 * 判断一个数据字典类型对象是否是树结构
	 * 
	 * @param form
	 * @return
	 */
	private boolean isTreeItem(BscDicCodeItem form) {
		if (form.getTypeCode() != null && form.getTypeCode().trim().length() > 0) {
			BscDicCodeType typeForm = bscDicCodeMapper.getTypeByTypeId(form.getTypeCode());
			if (logger.isDebugEnabled()) {
				logger.debug("根据数据字典类型ID{}获取数据字典类型对象{}。", form.getTypeCode(), JsonUtils.toJson(typeForm));
			}
			if (typeForm != null && typeForm.getTypeIsTree() != null && typeForm.getTypeIsTree().equals(Status.ONE)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 在保存一个树结构的数据字典类型的子项后，设置该子项的树结构信息
	 * 
	 * @param form
	 */
	public void setTreeInfoAfterSaveItem(BscDicCodeItem form) {
		if (form != null && form.getItemId() != null && form.getItemId().trim().length() > 0 && isTreeItem(form)) {

			// 有父节点
			if (form.getItemParentId() != null && form.getItemParentId().trim().length() > 0) {
				BscDicCodeItem parentItemForm = bscDicCodeMapper.getItemByItemId(form.getItemParentId());
				if (logger.isDebugEnabled()) {
					logger.debug("根据数据字典子项的主键值{}获取数据字典子项对象{}。", form.getItemParentId(),
							JsonUtils.toJson(parentItemForm));
				}
				if (parentItemForm != null) {
					String parentSeq = parentItemForm.getItemSeq();
					String newSeq = parentSeq + form.getItemId() + ".";

					// 序列
					form.setItemSeq(newSeq);
					// 层次
					form.setItemLevel(parentItemForm.getItemLevel() + 1);

					// 父节点孩子节点总数
					parentItemForm.setItemSubCount(parentItemForm.getItemSubCount() + 1);
				} else {
					form.setItemSeq("." + form.getItemId() + ".");
					form.setItemLevel(1);
				}
			}

			// 无父节点
			else {
				form.setItemSeq("." + form.getItemId() + ".");
				form.setItemLevel(1);
			}
		}
	}

	@Override
	public BscDicCodeItem getItemByItemCode(String typeCode, String itemCode) {
		return bscDicCodeMapper.getItemByTypeIdAndItemCode(typeCode, itemCode);
	}

	/**
	 * 获取所有子项
	 * 
	 * @return
	 */
	@Override
	public List<BscDicCodeItem> getAllItems(Map<String, Object> params) {
		return bscDicCodeMapper.getAllItems(params);
	}

	/**
	 * 
	 * @param params
	 * @return List<BscDicCodeItem>
	 * @Description TpecodeAndItemode查找
	 * @date 2016年4月8日
	 * @author kinda
	 */
	@Override
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> selectByTypecodeAndItemode(Map<String, Object> params) {
		return bscDicCodeMapper.selectByTypecodeAndItemode(params);
	}
	
	
	//**************************************************************************
	/**
	 * TODO 转换生成键值对数据 <br><pre>
	 * 编写者：yangjian@toonan.com
	 * 创建时间：2016年4月11日 下午5:48:33 </pre>
	 * @param 参数类型 参数名 说明
	 * @return typeCode 字典类型,itemCodes 子项编码数组
	 * @throws 异常类型 说明
	 */
	//**************************************************************************
	@Transactional(readOnly = true)
	public List<BscDicCodeItem> findConvertItems(String typeCode,String[] itemCodes){
		if (itemCodes == null || itemCodes.length == 0)
			throw new InvalidParameterMainError("itemCodes");

		// 先从缓存获取数据
		List<BscDicCodeItem> itemList = bscDicCodeMapper.findConvertItems(typeCode,itemCodes);

		if (logger.isDebugEnabled())
			logger.debug("成功获取字典子项列表，子项编号为：{}，返回记录数为{}。", itemCodes, itemList != null ? itemList.size() : null);
		
		return itemList;
	}
}
